/**
 * 添加500条聊天记录脚本
 * 模拟患者p001与医生d001之间的大量聊天记录
 */

const mongoose = require('../db/index');
const { LhxUser, LhxVisit, LhxMessage, LhxChatPermission } = require('../db/lhx_models');

// 定义患者和医生信息
const PATIENT_INFO = {
  userId: 'p001',
  name: '患者张三',
  userType: 'patient',
  avatar: '/avatars/patient1.jpg',
  phone: '13900001001',
  status: 'active'
};

const DOCTOR_INFO = {
  userId: 'd001',
  name: '张医生',
  userType: 'doctor',
  department: '内科',
  avatar: '/avatars/doctor1.jpg',
  phone: '13800001001',
  status: 'active'
};

const ROOM_ID = 'p001_d001';

// 患者可能发送的消息模板
const patientMessages = [
  '医生您好，我想咨询一下',
  '我最近感觉有点不舒服',
  '请问这个药需要怎么吃？',
  '症状有所好转，谢谢医生',
  '还需要继续用药吗？',
  '我按您说的做了，效果不错',
  '有什么需要注意的吗？',
  '复查结果出来了',
  '这个检查报告您帮我看看',
  '药物有副作用吗？',
  '什么时候需要复查？',
  '饮食方面有什么禁忌？',
  '运动强度要控制吗？',
  '睡眠质量最近不太好',
  '压力大会影响病情吗？',
  '需要调整治疗方案吗？',
  '家属需要注意什么？',
  '这种情况正常吗？',
  '谢谢医生的耐心解答',
  '我会按时服药的',
  '下次什么时候来复诊？',
  '费用大概是多少？',
  '有更便宜的替代药物吗？',
  '这个病会传染吗？',
  '需要住院治疗吗？',
  '可以正常工作吗？',
  '孩子也有类似症状',
  '是否需要做进一步检查？',
  '这个病会复发吗？',
  '预后怎么样？'
];

// 医生可能发送的消息模板
const doctorMessages = [
  '您好，请详细描述一下症状',
  '根据您的情况，建议这样治疗',
  '药物需要按时服用，一天三次',
  '注意休息，多喝水',
  '避免辛辣刺激性食物',
  '如有不适请及时联系',
  '检查结果基本正常',
  '需要调整用药剂量',
  '建议一周后复查',
  '这种情况比较常见，不用担心',
  '保持良好的生活习惯',
  '适量运动有助于恢复',
  '按照处方用药即可',
  '观察几天看看效果',
  '有问题随时咨询',
  '治疗效果还不错',
  '继续目前的治疗方案',
  '可以逐渐减少用药',
  '定期监测相关指标',
  '预防措施很重要',
  '家属配合治疗很关键',
  '心理调节也要重视',
  '饮食营养要均衡',
  '避免过度劳累',
  '按时作息很重要',
  '这个药物比较安全',
  '副作用一般很轻微',
  '治疗周期大概需要几周',
  '康复情况良好',
  '继续保持这种状态'
];

// 生成随机时间戳（最近7天内）
function generateRandomTimestamp() {
  const now = new Date();
  const sevenDaysAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
  const randomTime = sevenDaysAgo.getTime() + Math.random() * (now.getTime() - sevenDaysAgo.getTime());
  return new Date(randomTime);
}

// 生成随机文件信息
function generateRandomFileInfo(messageType) {
  switch (messageType) {
    case 'image':
      return {
        fileName: `image_${Date.now()}.jpg`,
        fileSize: Math.floor(Math.random() * 2000000) + 500000, // 0.5-2.5MB
        fileUrl: `/uploads/${Math.random().toString(36).substring(2, 15)}`,
        mimeType: 'image/jpeg',
        duration: 0
      };
    case 'file':
      return {
        fileName: `document_${Date.now()}.pdf`,
        fileSize: Math.floor(Math.random() * 5000000) + 1000000, // 1-6MB
        fileUrl: `/uploads/${Math.random().toString(36).substring(2, 15)}`,
        mimeType: 'application/pdf',
        duration: 0
      };
    case 'voice':
      return {
        fileName: `voice_${Date.now()}.mp3`,
        fileSize: Math.floor(Math.random() * 1000000) + 100000, // 0.1-1.1MB
        fileUrl: `/uploads/${Math.random().toString(36).substring(2, 15)}`,
        mimeType: 'audio/mpeg',
        duration: Math.floor(Math.random() * 180) + 10 // 10-190秒
      };
    default:
      return {};
  }
}

// 生成聊天消息
function generateChatMessages(count = 500) {
  const messages = [];
  const messageTypes = ['text', 'text', 'text', 'text', 'text', 'image', 'file', 'voice']; // 文本消息占大部分
  const statuses = ['sent', 'delivered', 'read'];
  
  for (let i = 0; i < count; i++) {
    const isPatientSender = Math.random() > 0.4; // 患者发送的概率60%
    const messageType = messageTypes[Math.floor(Math.random() * messageTypes.length)];
    const status = statuses[Math.floor(Math.random() * statuses.length)];
    
    let content = '';
    let fileInfo = {};
    
    if (messageType === 'text') {
      if (isPatientSender) {
        content = patientMessages[Math.floor(Math.random() * patientMessages.length)];
        // 有时候患者会发送较长的描述
        if (Math.random() > 0.7) {
          content += '，' + patientMessages[Math.floor(Math.random() * patientMessages.length)];
        }
      } else {
        content = doctorMessages[Math.floor(Math.random() * doctorMessages.length)];
        // 医生有时会给出详细的建议
        if (Math.random() > 0.6) {
          content += '，' + doctorMessages[Math.floor(Math.random() * doctorMessages.length)];
        }
      }
    } else {
      // 非文本消息的描述
      const descriptions = {
        image: isPatientSender ? '发送了一张图片' : '发送了检查报告图片',
        file: isPatientSender ? '发送了一个文件' : '发送了诊断书',
        voice: isPatientSender ? '发送了语音消息' : '发送了语音回复'
      };
      content = descriptions[messageType];
      fileInfo = generateRandomFileInfo(messageType);
    }
    
    const message = {
      roomId: ROOM_ID,
      senderId: isPatientSender ? PATIENT_INFO.userId : DOCTOR_INFO.userId,
      senderType: isPatientSender ? PATIENT_INFO.userType : DOCTOR_INFO.userType,
      content: content,
      messageType: messageType,
      timestamp: generateRandomTimestamp(),
      status: status,
      fileInfo: fileInfo
    };
    
    messages.push(message);
  }
  
  // 按时间排序
  messages.sort((a, b) => a.timestamp - b.timestamp);
  
  return messages;
}

// 确保用户存在
async function ensureUsersExist() {
  try {
    // 检查并创建患者
    let patient = await LhxUser.findOne({ userId: PATIENT_INFO.userId });
    if (!patient) {
      patient = await LhxUser.create(PATIENT_INFO);
      console.log('✅ 创建患者:', PATIENT_INFO.name);
    } else {
      console.log('✅ 患者已存在:', patient.name);
    }
    
    // 检查并创建医生
    let doctor = await LhxUser.findOne({ userId: DOCTOR_INFO.userId });
    if (!doctor) {
      doctor = await LhxUser.create(DOCTOR_INFO);
      console.log('✅ 创建医生:', DOCTOR_INFO.name);
    } else {
      console.log('✅ 医生已存在:', doctor.name);
    }
    
    return { patient, doctor };
  } catch (error) {
    console.error('❌ 创建用户失败:', error);
    throw error;
  }
}

// 确保就诊记录存在
async function ensureVisitExists() {
  try {
    let visit = await LhxVisit.findOne({ 
      patientId: PATIENT_INFO.userId, 
      doctorId: DOCTOR_INFO.userId 
    });
    
    if (!visit) {
      const visitData = {
        visitId: `v_${PATIENT_INFO.userId}_${DOCTOR_INFO.userId}_${Date.now()}`,
        patientId: PATIENT_INFO.userId,
        doctorId: DOCTOR_INFO.userId,
        visitDate: new Date(Date.now() - 2 * 24 * 60 * 60 * 1000), // 2天前
        department: DOCTOR_INFO.department,
        diagnosis: '常规健康咨询',
        visitType: 'first_visit',
        status: 'completed'
      };
      
      visit = await LhxVisit.create(visitData);
      console.log('✅ 创建就诊记录:', visit.visitId);
    } else {
      console.log('✅ 就诊记录已存在:', visit.visitId);
    }
    
    return visit;
  } catch (error) {
    console.error('❌ 创建就诊记录失败:', error);
    throw error;
  }
}

// 确保聊天权限存在
async function ensureChatPermissionExists() {
  try {
    let permission = await LhxChatPermission.findOne({
      patientId: PATIENT_INFO.userId,
      doctorId: DOCTOR_INFO.userId,
      isActive: true
    });
    
    if (!permission) {
      const permissionData = {
        patientId: PATIENT_INFO.userId,
        doctorId: DOCTOR_INFO.userId,
        permissionType: 'allowed',
        source: 'visit',
        isActive: true,
        metadata: {
          reason: '基于就诊记录自动授权'
        }
      };
      
      permission = await LhxChatPermission.create(permissionData);
      console.log('✅ 创建聊天权限');
    } else {
      console.log('✅ 聊天权限已存在');
    }
    
    return permission;
  } catch (error) {
    console.error('❌ 创建聊天权限失败:', error);
    throw error;
  }
}

// 主函数
async function addChatMessages() {
  try {
    console.log('🚀 开始添加500条聊天记录...');
    
    // 1. 确保用户存在
    console.log('\n1. 检查用户信息...');
    await ensureUsersExist();
    
    // 2. 确保就诊记录存在
    console.log('\n2. 检查就诊记录...');
    await ensureVisitExists();
    
    // 3. 确保聊天权限存在
    console.log('\n3. 检查聊天权限...');
    await ensureChatPermissionExists();
    
    // 4. 生成聊天消息
    console.log('\n4. 生成聊天消息...');
    const messages = generateChatMessages(500);
    console.log(`✅ 生成了${messages.length}条消息`);
    
    // 5. 清理现有的聊天记录（可选）
    console.log('\n5. 清理现有聊天记录...');
    const existingCount = await LhxMessage.countDocuments({ roomId: ROOM_ID });
    if (existingCount > 0) {
      await LhxMessage.deleteMany({ roomId: ROOM_ID });
      console.log(`✅ 删除了${existingCount}条现有消息`);
    }
    
    // 6. 批量插入消息
    console.log('\n6. 插入聊天消息到数据库...');
    await LhxMessage.insertMany(messages);
    console.log('✅ 成功插入500条聊天记录');
    
    // 7. 验证数据
    console.log('\n7. 验证数据...');
    const totalMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID });
    const textMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, messageType: 'text' });
    const imageMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, messageType: 'image' });
    const fileMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, messageType: 'file' });
    const voiceMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, messageType: 'voice' });
    const patientMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, senderType: 'patient' });
    const doctorMessages = await LhxMessage.countDocuments({ roomId: ROOM_ID, senderType: 'doctor' });
    
    console.log('\n📊 数据统计:');
    console.log(`- 总消息数: ${totalMessages}`);
    console.log(`- 文本消息: ${textMessages}`);
    console.log(`- 图片消息: ${imageMessages}`);
    console.log(`- 文件消息: ${fileMessages}`);
    console.log(`- 语音消息: ${voiceMessages}`);
    console.log(`- 患者发送: ${patientMessages}`);
    console.log(`- 医生发送: ${doctorMessages}`);
    
    console.log('\n🎉 500条聊天记录添加完成！');
    console.log(`💬 房间号: ${ROOM_ID}`);
    console.log(`👨‍⚕️ 医生: ${DOCTOR_INFO.name} (${DOCTOR_INFO.userId})`);
    console.log(`🤒 患者: ${PATIENT_INFO.name} (${PATIENT_INFO.userId})`);
    
    console.log('\n🔍 测试API:');
    console.log(`GET /lhx/messages/${ROOM_ID} - 获取聊天记录`);
    console.log(`GET /lhx/patient/${PATIENT_INFO.userId}/doctors - 获取患者可聊天医生`);
    console.log(`GET /lhx/doctor/${DOCTOR_INFO.userId}/patients - 获取医生的聊天患者`);
    
  } catch (error) {
    console.error('❌ 添加聊天记录失败:', error);
    throw error;
  }
}

// 如果直接运行此脚本
if (require.main === module) {
  addChatMessages()
    .then(() => {
      console.log('\n✅ 脚本执行完成');
      process.exit(0);
    })
    .catch((error) => {
      console.error('\n❌ 脚本执行失败:', error);
      process.exit(1);
    });
}

module.exports = {
  addChatMessages,
  PATIENT_INFO,
  DOCTOR_INFO,
  ROOM_ID
};